import 'dart:io';

import 'package:dio/dio.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:hive_flutter/hive_flutter.dart';
import 'package:path_provider/path_provider.dart';
import 'package:uuid/uuid.dart';
import 'package:family_app/src/common/constants.dart';
import 'package:family_app/src/features/auth/services/auth_service.dart';
import 'package:family_app/src/features/gallery/models/album_model.dart';
import 'package:family_app/src/features/gallery/models/photo_model.dart';

/// 相册服务提供者
final galleryServiceProvider = Provider<GalleryService>((ref) {
  // 创建用于相册API的Dio实例
  final dio = Dio(BaseOptions(
    baseUrl: AppConstants.apiBaseUrl,
    connectTimeout: const Duration(seconds: 5),
    receiveTimeout: const Duration(seconds: 30),
  ));
  
  // 创建专门用于相册服务的Dio实例，使用特定的基础URL
  final albumDio = Dio(BaseOptions(
    baseUrl: 'http://10.0.2.2:9092',  // 相册服务的特定域名
    connectTimeout: const Duration(seconds: 5),
    receiveTimeout: const Duration(seconds: 10),
    headers: {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
    },
  ));
  
  // 添加日志拦截器，方便调试
  albumDio.interceptors.add(LogInterceptor(
    requestBody: true,
    responseBody: true,
  ));
  
  // 获取认证服务
  final authService = ref.read(authServiceProvider);
  
  return GalleryService(dio, albumDio, authService);
});

/// 相册服务
class GalleryService {
  final Dio _dio;
  final Dio _albumDio; // 专门用于相册API的Dio实例
  final AuthService _authService; // 认证服务，用于获取用户信息
  final _galleryBox = Hive.box(AppConstants.galleryBox);
  final _uuid = const Uuid();

  GalleryService(this._dio, this._albumDio, this._authService);
  
  /// 保存相册列表到本地存储
  Future<void> _saveAlbums(List<AlbumModel> albums) async {
    try {
      final albumsJson = albums.map((album) => album.toJson()).toList();
      await _galleryBox.put('albums', albumsJson);
    } catch (e) {
      print('保存相册失败: $e');
    }
  }

  /// 保存照片列表到本地存储
  Future<void> _savePhotos(String albumId, List<PhotoModel> photos) async {
    try {
      final photosJson = photos.map((photo) => photo.toJson()).toList();
      await _galleryBox.put('photos_$albumId', photosJson);
    } catch (e) {
      print('保存照片失败: $e');
    }
  }

  /// 获取图片缓存目录
  Future<Directory> getImageCacheDir() async {
    final appDir = await getApplicationDocumentsDirectory();
    final cacheDir = Directory('${appDir.path}/image_cache');
    if (!await cacheDir.exists()) {
      await cacheDir.create(recursive: true);
    }
    return cacheDir;
  }
  
  /// 获取相册中的照片
  Future<List<PhotoModel>> getPhotos(String albumId) async {
    try {
      // 从本地存储获取照片列表
      final photosData = _galleryBox.get('photos_$albumId');
      if (photosData != null) {
        return (photosData as List)
            .map((json) => PhotoModel.fromJson(Map<String, dynamic>.from(json)))
            .toList();
      }
      return [];
    } catch (e) {
      print('获取照片列表异常: $e');
      return [];
    }
  }

  /// 获取所有相册
  Future<List<AlbumModel>> getAlbums() async {
    try {
      // 尝试从接口获取相册列表
      final remoteAlbums = await getAlbumsFromApi();
      if (remoteAlbums.isNotEmpty) {
        // 如果成功从接口获取数据，则更新本地缓存并返回
        await _saveAlbums(remoteAlbums);
        return remoteAlbums;
      }
      
      // 如果接口获取失败，则尝试从本地存储获取相册列表
      final albumsData = _galleryBox.get('albums');
      if (albumsData != null) {
        return (albumsData as List)
            .map((json) => AlbumModel.fromJson(Map<String, dynamic>.from(json)))
            .toList();
      }

      // 如果本地也没有数据，则直接返回空列表
      return [];
    } catch (e) {
      print('获取相册列表异常: $e');
      return [];
    }
  }

  /// 从API获取相册列表
  Future<List<AlbumModel>> getAlbumsFromApi() async {
    try {
      // 从本地存储获取当前登录用户信息
      final currentUser = _authService.getCurrentUser();
      // 如果用户未登录，则返回空列表
      if (currentUser == null) {
        print('用户未登录，无法获取相册列表');
        return [];
      }
      
      // 获取用户ID
      final userId = currentUser.id;
      print('当前用户ID: $userId');
      
      // 调用相册列表接口
      final response = await _albumDio.get('/album/list', queryParameters: {
        'userId': userId,
      });
      
      print('获取相册列表响应: ${response.data}');
      
      // 处理响应
      if (response.statusCode == 200 && response.data != null) {
        final responseData = response.data;
        
        // 检查接口返回的状态码
        if (responseData['code'] == '200' && responseData['data'] != null) {
          final List<dynamic> albumsData = responseData['data'];
          
          // 将接口返回的数据转换为AlbumModel列表
          return albumsData.map((albumData) {
            final now = DateTime.now();
            // 创建AlbumModel对象，注意字段映射
            return AlbumModel(
              id: albumData['id'].toString(), // 将int转为String
              name: albumData['albumName'] ?? '', // 接口返回的是albumName
              coverUrl: albumData['albumCover'], // 接口返回的是albumCover
              description: albumData['description'] ?? '', // 接口可能没有返回description字段
              createdAt: albumData['createTime'] != null 
                  ? DateTime.parse(albumData['createTime']) 
                  : now,
              updatedAt: albumData['updateTime'] != null 
                  ? DateTime.parse(albumData['updateTime']) 
                  : now,
              photoCount: albumData['photoSize'] ?? 0, // 接口返回的是photoSize
            );
          }).toList();
        }
      }
      
      // 如果接口调用失败或返回数据格式不正确，则返回空列表
      return [];
    } catch (e) {
      print('从API获取相册列表异常: $e');
      return [];
    }
  }

  /// 获取指定相册
  Future<AlbumModel?> getAlbum(String albumId) async {
    try {
      // 获取所有相册
      final albums = await getAlbums();
      // 查找指定ID的相册
      return albums.firstWhere((album) => album.id == albumId);
    } catch (e) {
      print('获取相册异常: $e');
      return null;
    }
  }

  /// 创建相册
  Future<AlbumModel?> createAlbum(String name, {String? description}) async {
    try {
      // 从本地存储获取当前登录用户信息
      final currentUser = _authService.getCurrentUser();
      // 如果用户未登录，则无法创建相册
      if (currentUser == null) {
        print('用户未登录，无法创建相册');
        return null;
      }
      
      // 获取用户ID
      final userId = currentUser.id;
      
      // 调用创建相册接口
      final response = await _albumDio.post('/album/create', data: {
        'userId': userId,
        'albumName': name,
        'description': description ?? '',
      });
      
      print('创建相册响应: ${response.data}');
      
      // 处理响应
      if (response.statusCode == 200 && response.data != null) {
        final responseData = response.data;
        
        // 检查接口返回的状态码
        if (responseData['code'] == '200' && responseData['data'] != null) {
          final albumData = responseData['data'];
          final now = DateTime.now();
          
          // 创建AlbumModel对象
          final newAlbum = AlbumModel(
            id: albumData['id'].toString(),
            name: name,
            coverUrl: null, // 新创建的相册没有封面
            description: description,
            createdAt: now,
            updatedAt: now,
            photoCount: 0, // 新创建的相册没有照片
          );
          
          // 获取当前相册列表
          final albums = await getAlbums();
          // 添加新相册
          albums.add(newAlbum);
          // 保存到本地存储
          await _saveAlbums(albums);
          
          return newAlbum;
        }
      }
      
      return null;
    } catch (e) {
      print('创建相册异常: $e');
      return null;
    }
  }

  /// 更新相册
  Future<AlbumModel?> updateAlbum(String albumId, {String? name, String? description}) async {
    try {
      // 获取当前相册列表
      final albums = await getAlbums();
      // 查找指定ID的相册
      final albumIndex = albums.indexWhere((album) => album.id == albumId);
      
      if (albumIndex == -1) {
        print('相册不存在: $albumId');
        return null;
      }
      
      // 获取原相册信息
      final album = albums[albumIndex];
      
      // 调用更新相册接口
      final response = await _albumDio.post('/album/update', data: {
        'id': albumId,
        'albumName': name ?? album.name,
        'description': description ?? album.description ?? '',
      });
      
      print('更新相册响应: ${response.data}');
      
      // 处理响应
      if (response.statusCode == 200 && response.data != null) {
        final responseData = response.data;
        
        // 检查接口返回的状态码
        if (responseData['code'] == '200') {
          // 更新相册信息
          final updatedAlbum = album.copyWith(
            name: name ?? album.name,
            description: description ?? album.description,
            updatedAt: DateTime.now(),
          );
          
          // 更新相册列表
          albums[albumIndex] = updatedAlbum;
          // 保存到本地存储
          await _saveAlbums(albums);
          
          return updatedAlbum;
        }
      }
      
      return null;
    } catch (e) {
      print('更新相册异常: $e');
      return null;
    }
  }

  /// 删除相册
  Future<bool> deleteAlbum(String albumId) async {
    try {
      // 调用删除相册接口
      final response = await _albumDio.post('/album/delete', data: {
        'id': albumId,
      });
      
      print('删除相册响应: ${response.data}');
      
      // 处理响应
      if (response.statusCode == 200 && response.data != null) {
        final responseData = response.data;
        
        // 检查接口返回的状态码
        if (responseData['code'] == '200') {
          // 获取当前相册列表
          final albums = await getAlbums();
          // 移除指定ID的相册
          albums.removeWhere((album) => album.id == albumId);
          // 保存到本地存储
          await _saveAlbums(albums);
          
          // 删除相册下的所有照片
          await _galleryBox.delete('photos_$albumId');
          
          return true;
        }
      }
      
      return false;
    } catch (e) {
      print('删除相册异常: $e');
      return false;
    }
  }

  /// 添加照片到相册
  Future<PhotoModel?> addPhoto(String albumId, String localPath, {String? name, String? description}) async {
    try {
      // 获取指定相册
      final album = await getAlbum(albumId);
      if (album == null) {
        print('相册不存在: $albumId');
        return null;
      }
      
      // 生成唯一ID
      final photoId = _uuid.v4();
      // 获取当前时间
      final now = DateTime.now();
      
      // 创建照片对象
      final newPhoto = PhotoModel(
        id: photoId,
        albumId: albumId,
        name: name ?? '照片_${now.millisecondsSinceEpoch}',
        description: description,
        localPath: localPath,
        url: null, // 本地照片没有远程URL
        createdAt: now,
        updatedAt: now,
      );
      
      // 获取当前相册的照片列表
      final photos = await getPhotos(albumId);
      // 添加新照片
      photos.add(newPhoto);
      // 保存到本地存储
      await _savePhotos(albumId, photos);
      
      // 更新相册信息
      final updatedAlbum = album.copyWith(
        photoCount: album.photoCount + 1,
        coverUrl: album.coverUrl ?? localPath, // 如果相册没有封面，则使用新照片作为封面
        updatedAt: now,
      );
      
      // 获取当前相册列表
      final albums = await getAlbums();
      // 更新相册信息
      final albumIndex = albums.indexWhere((a) => a.id == albumId);
      if (albumIndex != -1) {
        albums[albumIndex] = updatedAlbum;
        // 保存到本地存储
        await _saveAlbums(albums);
      }
      
      return newPhoto;
    } catch (e) {
      print('添加照片异常: $e');
      return null;
    }
  }

  /// 删除照片
  Future<bool> deletePhoto(String albumId, String photoId) async {
    try {
      // 获取指定相册的照片列表
      final photos = await getPhotos(albumId);
      // 查找指定ID的照片
      final photoIndex = photos.indexWhere((photo) => photo.id == photoId);
      
      if (photoIndex == -1) {
        print('照片不存在: $photoId');
        return false;
      }
      
      // 获取照片信息
      final photo = photos[photoIndex];
      
      // 调用删除照片接口
      final response = await _albumDio.post('/photo/delete', data: {
        'id': photoId,
        'albumId': albumId,
      });
      
      print('删除照片响应: ${response.data}');
      
      // 处理响应
      if (response.statusCode == 200 && response.data != null) {
        final responseData = response.data;
        
        // 检查接口返回的状态码
        if (responseData['code'] == '200') {
          // 移除照片
          photos.removeAt(photoIndex);
          // 保存到本地存储
          await _savePhotos(albumId, photos);
          
          // 更新相册信息
          final album = await getAlbum(albumId);
          if (album != null) {
            final updatedAlbum = album.copyWith(
              photoCount: album.photoCount - 1,
              // 如果删除的照片是封面，则更新封面
              coverUrl: album.coverUrl == photo.localPath || album.coverUrl == photo.url
                  ? (photos.isNotEmpty ? photos.first.localPath ?? photos.first.url : null)
                  : album.coverUrl,
              updatedAt: DateTime.now(),
            );
            
            // 获取当前相册列表
            final albums = await getAlbums();
            // 更新相册信息
            final albumIndex = albums.indexWhere((a) => a.id == albumId);
            if (albumIndex != -1) {
              albums[albumIndex] = updatedAlbum;
              // 保存到本地存储
              await _saveAlbums(albums);
            }
          }
          
          return true;
        }
      }
      
      // 如果API调用失败，返回失败
      print('删除照片API调用失败');
      return false;
    } catch (e) {
      print('删除照片异常: $e');
      return false;
    }
  }
}
